﻿using DAL.Repositories;
using DAL.Repositorios;
using EntitiesLayer;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DAL.RepositoryInterfaces;


namespace DAL
{
    public class UnitOfWork
    {
        private static ParametrosSistemaRepository _parametrosSistemaRepository;
        public static ParametrosSistemaRepository ParametrosSistemaRepository
        {
            get
            {
                if (_parametrosSistemaRepository == null)
                    _parametrosSistemaRepository = new ParametrosSistemaRepository();

                return _parametrosSistemaRepository;
            }
        }

        private IRepository<CorreoElectronico> repositoryCorreo;

        private IRepository<HorarioDia> repositoryHorarioDia;

        private static IRepository<Ejercicio> repositoryEjercicio;

        public static IRepository<Ejercicio> RepositoryEjercicio
        {
            get 
            {
                if (repositoryEjercicio == null)
                    repositoryEjercicio = new EjercicioRepository();

                return repositoryEjercicio;
            }
        }
        
        public static IRandomReposiotry<Ejercicio> RandomRepoEjercicio
        {
            get
            {
                if (repositoryEjercicio == null)
                    repositoryEjercicio = new EjercicioRepository();

                return (IRandomReposiotry<Ejercicio>)repositoryEjercicio;
            }
        }

        private IRepositoryRegistrar<Exception> repositoryException;

        private IRepository<Imagen> repositoryImagen;

        private static IRepository<Maquina> maquinaRepository;
        public static IRepository<Maquina> MaquinaRepository
        {
            get
            {
                if (maquinaRepository == null)
                    maquinaRepository = new MaquinaRepository();

                return maquinaRepository;
            }
        }

        private static IClientesRepository clienteRepository;

        public static IClientesRepository ClienteRepository
        {

            get
            {
                if (clienteRepository == null)
                    clienteRepository = new ClienteRepository();

                return clienteRepository;
            }
        }

        
        private static IRepository<Usuario> usuarioManRepository;
        public static IRepository<Usuario> UsuarioManRepository {

            get 
            {
                if (usuarioManRepository == null)
                    usuarioManRepository = new UsuarioManRepository();
                
                return usuarioManRepository;
            
            }
        }

        public IRepositoryUsuarioSesion<Usuario> RepositoryUsuario
        {
            get
            {
                if (usuarioManRepository == null)
                {
                    usuarioManRepository = new UsuarioManRepository();
                }
                return (IRepositoryUsuarioSesion<Usuario>)usuarioManRepository;
            }
        }

        private static IRepository<Telefono> telefonosUsuario;
        public static IRepository<Telefono> TelefonosUsuarios {

            get 
            {
                if (telefonosUsuario == null)
                    telefonosUsuario = new TelefonoUsuarioRepository();

                return telefonosUsuario;
            
            
            }
        }

        private IRepositoryRelations<long, long> maquinaMusculoP;

        private static IRepository<Musculos> repositoryMusculo;
        public static IRepository<Musculos> RepositoryMusculo
        {

            get
            {
                if (repositoryMusculo == null)
                {
                    repositoryMusculo = new MusculoRepository();
                }   
                return repositoryMusculo;
            }
        }


        private IRepository<Notificacion> repositoryNotificacion;

        private static IRepositoryRegistrar<Pago> pagoRepositoryRegistrar;
        public static IRepositoryRegistrar<Pago> PagoRepositoryRegistrar
        {
            get
            {
                if (pagoRepositoryRegistrar == null)
                    pagoRepositoryRegistrar = new PagoRepository();

                return pagoRepositoryRegistrar;
            }
        }

        private static IRepositoryConsultar<Pago> pagoRepositoryConsultar;
        public static IRepositoryConsultar<Pago> PagoRepositoryConsultar
        {
            get
            {
                if (pagoRepositoryConsultar == null)
                    pagoRepositoryConsultar = new PagoRepository();

                return pagoRepositoryConsultar;
            }
        }
            
        private IRepository<Referencia> repositoryReferencia;

        private IRepositoryConsultar<Permiso> repositoryPermiso;

        private IRepository<Rol> repositoryRol;

        private IRepository<Telefono> TelefonoReferencia;

        private IRepository<Telefono> TelefonoUsuario;

        private IRepositoryUsuarioSesion<UsuarioSimple> repositoryUsuario;

       

        private  static IRepository<CorreoElectronico> correoElectronicoRepository;
        public static IRepository<CorreoElectronico> CorreoElectronicoRepository{

            get 
            {
                if (correoElectronicoRepository == null)
                    correoElectronicoRepository = new CorreoElectronicoRepository();

                return correoElectronicoRepository;
            }
        }
        private static IRepository<Referencia> referenciasRepository;
        public static IRepository<Referencia> ReferenciasRepository {

            get 
            {
                if (referenciasRepository == null)
                    referenciasRepository = new ReferenciaRepository();

                return referenciasRepository;
            }
        }

        private static IRepositoryByKey<string, IList<string>> constantesRepository;

        public static IRepositoryByKey<string, IList<string>> ConstantesRepository {

            get
            {
                if (constantesRepository == null)
                    constantesRepository = new ConstantesReadOnlyRepository();

                return constantesRepository;
            }
        }

        private static IRepository<Rol> rolRepository;

        public static IRepository<Rol> RolRepository {

            get 
            {
                if (rolRepository == null)
                    rolRepository = new RolRepository();

                return rolRepository;
            }
        }

        private static IRepositoryRelations<long, long> rolRelacionRepository;
        public static IRepositoryRelations<long, long> RolRelacionRepository { 
        
            get{
                if (rolRelacionRepository == null)
                    rolRelacionRepository = new RepsitoryRelacionRolPermiso();

                return rolRelacionRepository;
            }
        }

        private static IRepositoryConsultar<Permiso> permisoRepository;
        public static IRepositoryConsultar<Permiso> PermisoRepository 
        {

            get 
            {
                if (permisoRepository == null)
                    permisoRepository = new RepositoryPermisos();

                return permisoRepository;
            
            }
        }

        public static IRepositoryModificar<Permiso> PermisoRepositoryModificar {
            get
            {
                if (permisoRepository == null)
                    permisoRepository = new RepositoryPermisos();

                return (IRepositoryModificar<Permiso>)permisoRepository;
            }
        }
        private static IRepositoryConsultar<Funcionario> repoEFuncionario;
        public static IRepositoryConsultar<Funcionario> RepoEFuncionario {

            get
            {
                if (repoEFuncionario == null)
                    repoEFuncionario = new FuncionarioRepository();

                return repoEFuncionario;
            }
        }

        private static IRepository<Telefono> telefonoReferencia;

        public static IRepository<Telefono> TelefonoReferenciaRepo
        {

            get
            {
                if (telefonoReferencia == null)
                    telefonoReferencia = new TelefonoReferenciaRepository();

                return telefonoReferencia;
            }
        }

        private static IRepository<HorarioDia> repoHoraiosFuncionario;
        public static IRepository<HorarioDia> RepoHoraiosFuncionario {
            get
            {
                if (repoHoraiosFuncionario == null)
                    repoHoraiosFuncionario = new DiasHorarioRepository();

                return repoHoraiosFuncionario;
            }
        
        }

        private static IRepositoryRelations<long, long> repositoryMPrimarioXEjercicio;

        public static IRepositoryRelations<long,long> RepositoryMPrimarioXEjercicio {

            get {

                if (repositoryMPrimarioXEjercicio == null)
                    repositoryMPrimarioXEjercicio = new RepositoryRelacionMPEjercicio();

                return repositoryMPrimarioXEjercicio;
            }
        }

        private static IRepositoryRelations<long, long> repositoryMSecundarioXEjercicio;

        public static IRepositoryRelations<long,long> RepositoryMSecundarioXEjercicio
        {

            get
            {

                if (repositoryMSecundarioXEjercicio == null)
                    repositoryMSecundarioXEjercicio = new RepositoryRelacionMSEjercicio();

                return repositoryMSecundarioXEjercicio;
            }
        }

       

        private static IRepository<Imagen> repositoryImagenes;

        public static IRepository<Imagen> RepositoryImagenes {

            get {
                if (repositoryImagenes == null)
                    repositoryImagenes = new ImagenRepository();

                return repositoryImagenes;

            }
        }

        private static IRepositoryNotificaciones reposiotryNotificaciones;


        private static IRepositoryRegistrar<PruebaResistencia> repositoryPrueba;

        private static IRepositoryRegistrar<DetallePrueba> repositoryDetallePrueba;

        private static IRepository<Cita> repositoryCita;

        public static IRepository<Cita> RepositoryCita
        {
            get
            {
                if (repositoryCita == null)
                    repositoryCita = new CitasRepository();

                return repositoryCita;
            }
        }

        private static IRepositoryConsultar<TipoCita> repositoryTipoCita;

        public static IRepositoryConsultar<TipoCita> RepositoryTipoCita
        {
            get 
            {
                if (repositoryTipoCita == null)
                    repositoryTipoCita = new TipoCitaRepository();

                return repositoryTipoCita;
            }
        }

      

        



        private static IRepositoryRegistrar<RegistroMedida> repositoryRegistroMedida;

        private static IRepositoryRegistrar<Pliegue> repsitoryPliegue;

        private static IRepositoryRegistrar<Perimetro> repositoryPerimetro;


        private static IRepositoryConsultar<ObjetivoPE> repositoryObjetivos;
        public static IRepositoryConsultar<ObjetivoPE> RepositoryObjetivos
        {
            get
            {
                if (repositoryObjetivos == null)
                    repositoryObjetivos = new RepoObjetivosReadOnly();

                return repositoryObjetivos;

            }
        }

        private static IRepository<PlanEntrenamiento> repositoryPlanE;
        public static IRepository<PlanEntrenamiento> RepositoryPlanE
        {
            get
            {
                if (repositoryPlanE == null)
                    repositoryPlanE = new PlanEntrenamientoRepository();

                return repositoryPlanE;

            }
        }

        private  static IRepository<DetallePlan> repositoryDetalles;

        public static IRepository<DetallePlan> RepositoryDetalles {

            get {
                if (repositoryDetalles == null) {

                    repositoryDetalles = new DetallesPlanRepository();
                }

                return repositoryDetalles;
            
            }
        }

        private static IRepositoryConsultar<TipoMaquina> repositoryTipoMaquina;
        public static IRepositoryConsultar<TipoMaquina> RepositoryTipoMaquina
        {
            get
            {
                if (repositoryTipoMaquina == null)
                    repositoryTipoMaquina = new TipoMaquinaRepository();

                return repositoryTipoMaquina;

            }
        }
    
    }
}
